package com.seecen.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.seecen.common.BaseResponse;
import com.seecen.common.ResultUtils;
import com.seecen.exception.ErrorCode;
import com.seecen.pojo.entity.Order;
import com.seecen.service.OrderService;
import com.seecen.mapper.OrderMapper;
import com.seecen.utils.FileUploadUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
* @author 17549
* @description 针对表【allmaster_order(订单表)】的数据库操作Service实现
* @createDate 2025-10-21 15:30:48
*/
// com/seecen/service/impl/OrderServiceImpl.java
@Slf4j
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order>
        implements OrderService {
    @Autowired
    private OrderMapper orderMapper;

    @Override
    public BaseResponse<?> createOrder(Map<String, Object> orderData) {
        try {
            log.info("=== OrderServiceImpl.createOrder 开始 ===");
            log.info("接收到的订单数据: {}", orderData);

            // 从前端数据创建订单对象
            Order order = this.buildOrderFromData(orderData);

            return this.saveOrder(order);

        } catch (Exception e) {
            log.error("创建订单异常", e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "创建订单时发生错误: " + e.getMessage());
        }
    }

    /**
     * 从前端数据构建订单对象
     */
    private Order buildOrderFromData(Map<String, Object> orderData) {
        Order order = new Order();

        // 设置用户ID和服务ID
        Object userIdObj = orderData.get("userId");
        Object serviceIdObj = orderData.get("serviceId");

        if (userIdObj != null) {
            if (userIdObj instanceof Number) {
                order.setUserid(((Number) userIdObj).longValue());
            } else {
                order.setUserid(Long.parseLong(userIdObj.toString()));
            }
        }

        if (serviceIdObj != null) {
            if (serviceIdObj instanceof Number) {
                order.setServiceid(((Number) serviceIdObj).longValue());
            } else {
                order.setServiceid(Long.parseLong(serviceIdObj.toString()));
            }
        }

        // 设置其他订单信息
        order.setAddress((String) orderData.get("address"));
        order.setItemType((String) orderData.get("itemType"));
        order.setRepairTypes((String) orderData.get("repairTypes"));
        order.setDemandDescription((String) orderData.get("demandDescription"));
        order.setPictures((String) orderData.get("pictures"));

        // 设置地区信息
        Object provinceIdObj = orderData.get("provinceId");
        Object cityIdObj = orderData.get("cityId");
        if (provinceIdObj != null) {
            order.setProvinceId(Long.parseLong(provinceIdObj.toString()));
        }
        if (cityIdObj != null) {
            order.setCityId(Long.parseLong(cityIdObj.toString()));
        }

        // 设置服务时间
        String serviceTimeStr = (String) orderData.get("serviceTime");
        if (serviceTimeStr != null && !serviceTimeStr.trim().isEmpty()) {
            try {
                log.info("正在解析服务时间字符串: {}", serviceTimeStr);
                Date serviceTime = this.parseServiceTime(serviceTimeStr);
                order.setServiceTime(serviceTime);
                log.info("成功解析服务时间: {}", serviceTime);
            } catch (Exception e) {
                log.warn("解析服务时间失败: {}, 错误: {}", serviceTimeStr, e.getMessage());
                // 如果解析失败，设置为当前时间
                order.setServiceTime(new Date());
            }
        }

        // 设置其他字段
        Object fastestArrivalTimeObj = orderData.get("fastestArrivalTime");
        if (fastestArrivalTimeObj != null) {
            order.setFastestArrivalTime(Integer.parseInt(fastestArrivalTimeObj.toString()));
        }

        // 设置默认值
        order.setStatus(0);
        order.setCreatetime(new Date());
        order.setUpdatetime(new Date());
        order.setIsdeleted(0);

        log.info("构建的订单对象: {}", order);
        return order;
    }

    /**
     * 保存订单（包含业务逻辑验证）
     */
    private BaseResponse<?> saveOrder(Order order) {
        try {
            log.info("=== OrderServiceImpl.createOrder 开始 ===");
            log.info("接收到的订单对象: {}", order);
            log.info("订单用户ID: {}", order.getUserid());
            log.info("订单服务ID: {}", order.getServiceid());

            // 基础参数校验
            if (order.getUserid() == null) {
                log.error("用户ID为空，订单对象: {}", order);
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "用户ID不能为空");
            }
            if (order.getServiceid() == null) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "服务ID不能为空");
            }
            if (order.getAddress() == null || order.getAddress().trim().isEmpty()) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "服务地址不能为空");
            }
            if (order.getItemType() == null || order.getItemType().trim().isEmpty()) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "物品类型不能为空");
            }
            if (order.getRepairTypes() == null || order.getRepairTypes().trim().isEmpty()) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "维修类型不能为空");
            }
            if (order.getDemandDescription() == null || order.getDemandDescription().trim().isEmpty()) {
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "需求说明不能为空");
            }

            // 校验图片URL格式
            String pictures = order.getPictures();
            if (pictures != null && !pictures.trim().isEmpty()) {
                try {
                    // 如果是JSON数组格式，直接存储
                    if (pictures.startsWith("[") && pictures.endsWith("]")) {
                        // JSON格式，直接存储
                        log.info("图片数据为JSON格式: {}", pictures);
                    } else {
                        // 如果是逗号分隔的URL，转换为JSON格式
                        String[] urls = pictures.split(",");
                        StringBuilder jsonBuilder = new StringBuilder("[");
                        for (int i = 0; i < urls.length; i++) {
                            String url = urls[i].trim();
                            if (!url.startsWith("http") && !url.startsWith("/app/")) {
                                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "图片URL格式错误: " + url);
                            }
                            jsonBuilder.append("\"").append(url).append("\"");
                            if (i < urls.length - 1) {
                                jsonBuilder.append(",");
                            }
                        }
                        jsonBuilder.append("]");
                        order.setPictures(jsonBuilder.toString());
                    }
                } catch (Exception e) {
                    log.error("处理图片数据异常: {}", e.getMessage());
                    return ResultUtils.error(ErrorCode.PARAMS_ERROR, "图片数据格式错误");
                }
            }

            // 设置默认值
            order.setStatus(0); // 0-待处理
            order.setCreatetime(new Date());
            order.setUpdatetime(new Date());
            order.setIsdeleted(0);

            // 保存订单
            log.info("准备保存订单到数据库: {}", order);
            boolean saveResult = this.save(order);
            log.info("数据库保存结果: {}", saveResult);
            if (!saveResult) {
                log.error("数据库保存订单失败: {}", order);
                return ResultUtils.error(ErrorCode.OPERATION_ERROR, "创建订单失败");
            }

            log.info("订单创建成功, 订单ID: {}", order.getOrderid());
            return ResultUtils.success(order.getOrderid());

        } catch (Exception e) {
            log.error("创建订单异常", e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "创建订单时发生错误");
        }
    }

    @Override
    public BaseResponse<?> getOrderDetail(Long orderId) {
        try {
            log.info("=== OrderServiceImpl.getOrderDetail 开始 ===");
            log.info("获取订单详情，订单ID: {}", orderId);

            // 参数校验
            if (orderId == null) {
                log.error("订单ID为空");
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "订单ID不能为空");
            }

            // 查询订单
            Order order = this.getById(orderId);
            if (order == null) {
                log.error("订单不存在，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "订单不存在");
            }

            // 检查订单是否被删除
            if (order.getIsdeleted() != null && order.getIsdeleted() == 1) {
                log.error("订单已被删除，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "订单已被删除");
            }

            log.info("成功获取订单详情: {}", order);
            return ResultUtils.success(order);

        } catch (Exception e) {
            log.error("获取订单详情异常，订单ID: {}", orderId, e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "获取订单详情时发生错误");
        }
    }

    @Override
    public BaseResponse<?> updateOrder(Long orderId, Map<String, Object> orderData) {
        try {
            log.info("=== OrderServiceImpl.updateOrder 开始 ===");
            log.info("更新订单ID: {}, 数据: {}", orderId, orderData);

            // 参数校验
            if (orderId == null) {
                log.error("订单ID为空");
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "订单ID不能为空");
            }

            // 检查订单是否存在
            Order existingOrder = this.getById(orderId);
            if (existingOrder == null) {
                log.error("订单不存在，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "订单不存在");
            }

            // 检查订单是否可以修改（例如：只有待处理状态的订单才能修改）
            if (existingOrder.getStatus() != 0) {
                log.error("订单状态不允许修改，当前状态: {}", existingOrder.getStatus());
                return ResultUtils.error(ErrorCode.OPERATION_ERROR, "订单状态不允许修改");
            }

            // 从请求数据构建更新的订单对象
            Order updatedOrder = this.buildOrderFromData(orderData);
            updatedOrder.setOrderid(orderId); // 保持原订单ID
            updatedOrder.setCreatetime(existingOrder.getCreatetime()); // 保持原创建时间
            updatedOrder.setUpdatetime(new Date()); // 更新修改时间
            updatedOrder.setUserid(existingOrder.getUserid()); // 保持原用户ID
            updatedOrder.setServiceid(existingOrder.getServiceid()); // 保持原服务ID

            // 验证更新的订单数据
            BaseResponse<?> validationResult = this.validateOrderForUpdate(updatedOrder);
            if (validationResult.getCode() != 200) {
                return validationResult;
            }

            // 执行更新
            boolean updateResult = this.updateById(updatedOrder);
            if (!updateResult) {
                log.error("数据库更新订单失败，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.OPERATION_ERROR, "更新订单失败");
            }

            log.info("订单更新成功，订单ID: {}", orderId);
            return ResultUtils.success(orderId);

        } catch (Exception e) {
            log.error("更新订单异常，订单ID: {}", orderId, e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "更新订单时发生错误: " + e.getMessage());
        }
    }

    /**
     * 验证订单更新数据
     */
    private BaseResponse<?> validateOrderForUpdate(Order order) {
        // 复用原有的验证逻辑
        if (order.getAddress() == null || order.getAddress().trim().isEmpty()) {
            return ResultUtils.error(ErrorCode.PARAMS_ERROR, "服务地址不能为空");
        }
        if (order.getItemType() == null || order.getItemType().trim().isEmpty()) {
            return ResultUtils.error(ErrorCode.PARAMS_ERROR, "物品类型不能为空");
        }
        if (order.getRepairTypes() == null || order.getRepairTypes().trim().isEmpty()) {
            return ResultUtils.error(ErrorCode.PARAMS_ERROR, "维修类型不能为空");
        }
        if (order.getDemandDescription() == null || order.getDemandDescription().trim().isEmpty()) {
            return ResultUtils.error(ErrorCode.PARAMS_ERROR, "需求说明不能为空");
        }

        return ResultUtils.success(null);
    }

    /**
     * 解析服务时间字符串，支持多种ISO格式
     */
    private Date parseServiceTime(String serviceTimeStr) throws Exception {
        // 去除字符串两端空格
        serviceTimeStr = serviceTimeStr.trim();

        try {
            // 尝试使用Java 8的时间API解析ISO字符串
            Instant instant = Instant.parse(serviceTimeStr);
            return Date.from(instant);
        } catch (Exception e1) {
            log.warn("使用Instant.parse解析失败，尝试其他格式");

            // 尝试不同的SimpleDateFormat格式
            String[] patterns = {
                "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",  // 2025-01-01T12:30:00.123Z
                "yyyy-MM-dd'T'HH:mm:ss'Z'",      // 2025-01-01T12:30:00Z
                "yyyy-MM-dd'T'HH:mm:ss.SSSXXX",  // 2025-01-01T12:30:00.123+08:00
                "yyyy-MM-dd'T'HH:mm:ssXXX",      // 2025-01-01T12:30:00+08:00
                "yyyy-MM-dd'T'HH:mm:ss"          // 2025-01-01T12:30:00
            };

            for (String pattern : patterns) {
                try {
                    SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                    Date result = sdf.parse(serviceTimeStr);
                    log.info("使用格式 {} 成功解析时间: {}", pattern, result);
                    return result;
                } catch (Exception e2) {
                    // 继续尝试下一个格式
                }
            }

            throw new Exception("无法解析时间字符串: " + serviceTimeStr);
        }
    }

    @Override
    public BaseResponse<?> queryOrder(Long userId) {
        try {
            log.info("=== OrderServiceImpl.queryOrder 开始 ===");
            log.info("查询用户ID: {} 的订单", userId);
            
            // 参数校验
            if (userId == null) {
                log.error("用户ID为空");
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "用户ID不能为空");
            }
            
            QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("userid", userId); // 使用正确的字段名
            queryWrapper.eq("isdeleted", 0); // 只查询未删除的订单
            queryWrapper.orderByDesc("createtime"); // 按创建时间倒序排列

            List<Order> orders = orderMapper.selectList(queryWrapper);
            log.info("查询到用户 {} 的订单数量: {}", userId, orders.size());
            
            return ResultUtils.success(orders);
            
        } catch (Exception e) {
            log.error("查询用户订单异常，用户ID: {}", userId, e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "查询订单时发生错误");
        }
    }

    @Override
    public BaseResponse<?> deleteOrder(Long orderId) {
        try {
            log.info("=== OrderServiceImpl.deleteOrder 开始 ===");
            log.info("删除订单，订单ID: {}", orderId);

            // 参数校验
            if (orderId == null) {
                log.error("订单ID为空");
                return ResultUtils.error(ErrorCode.PARAMS_ERROR, "订单ID不能为空");
            }

            // 检查订单是否存在
            Order order = this.getById(orderId);
            if (order == null) {
                log.error("订单不存在，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "订单不存在");
            }

            // 检查订单是否已被删除
            if (order.getIsdeleted() != null && order.getIsdeleted() == 1) {
                log.error("订单已被删除，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "订单已被删除");
            }

            // 检查订单状态是否允许删除（只有待支付状态的订单可以取消）
            if (order.getStatus() != null && order.getStatus() != 0) {
                log.error("订单状态不允许取消，订单ID: {}, 当前状态: {}", orderId, order.getStatus());
                return ResultUtils.error(ErrorCode.OPERATION_ERROR, "当前订单状态不允许取消");
            }

            // 执行逻辑删除（设置isdeleted=1）
            order.setIsdeleted(1);
            order.setStatus(3); // 设置状态为已取消
            boolean updateResult = this.updateById(order);
            
            if (updateResult) {
                log.info("订单删除成功，订单ID: {}", orderId);
                return ResultUtils.success("订单取消成功");
            } else {
                log.error("订单删除失败，订单ID: {}", orderId);
                return ResultUtils.error(ErrorCode.OPERATION_ERROR, "订单取消失败");
            }

        } catch (Exception e) {
            log.error("删除订单异常，订单ID: {}", orderId, e);
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "删除订单时发生错误");
        }
    }
}